package com.sinosoft.ptas.control;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.sinosoft.framework.core.api.domain.ApplicationEntity;
import com.sinosoft.framework.core.api.domain.ResourcePermissionEntity;
import com.sinosoft.framework.core.api.domain.RoleEntity;
import com.sinosoft.framework.core.api.domain.RoleUserRefEntity;
import com.sinosoft.framework.core.api.service.ApplicationService;
import com.sinosoft.framework.core.api.service.ResourceService;
import com.sinosoft.framework.core.api.service.RoleService;
import com.sinosoft.framework.core.common.constants.ErrorConstants;
import com.sinosoft.framework.core.common.constants.RoleConstants;
import com.sinosoft.framework.core.common.constants.UserConstants;
import com.sinosoft.framework.core.common.exception.BusinessException;
import com.sinosoft.framework.core.common.utils.StringUtil;
import com.sinosoft.framework.core.common.utils.ajax.ResponseData;
import com.sinosoft.ptas.control.dto.ResponseMapData;
import com.sinosoft.ptas.control.dto.RoleData;
/**
 * 角色控制层 功能：创建角色、创建角色用户关系、
 * 				检索角色（角色编号、应用类型）、根据角色编号获取角色资源对应关系、根据角色编号获取角色用户对应关系
 * 				更新角色、创建和更新角色资源关系、根据用户编号获取用户角色对应关系、
 *              根据编号删除角色、根据角色编号、用户编号集合删除角色用户关系、
 *              校验角色（角色名称）。
 * @author lianWuJun
 * @time   2017年2月22日 下午2:56:23
 */
@Controller
@RequestMapping("role")
public class RoleController {
	
	@Autowired
	RoleService roleService;
	
	@Autowired
	ResourceService resourceService;
	
	@Autowired
	ApplicationService applicationService;
	
	/**
	 * 创建角色
	 * 包含编号、应用编号、名称、描述、创建者、创建时间
	 * @param roleData	角色传输实体
	 * @return roleData 角色传输实体
	 * @throws BusinessException	业务异常
	 */
	@RequestMapping(value="/createRole.service" ,method=RequestMethod.POST)
	@ResponseBody
	public ResponseData createRole(RoleData roleData){
		try{
			if(roleData==null){
				return new ResponseData(false,ErrorConstants.DATA_NULL_CODE,ErrorConstants.DATA_NULL_MESSAGE,null);
			}
			roleData.setId(UUID.randomUUID().toString());
			roleService.createRole(roleData.toRoleEntity());
			return new ResponseData(true,roleData);
		}catch(BusinessException e){
			return new ResponseData(false,e.getErrorCode(),e.getMessage(),null);
		}
	}
	
	/**
	 * 创建角色用户关系
	 * 批量创建角色编号为rid，用户编号集合为uids的角色用户关系
	 * 若不存在角色编号为rid的角色，则抛出业务异常“角色添加用户失败，角色不存在。”
	 * 若有不存在用户编号为uid的用户，则抛出业务异常“角色添加用户失败，存在无法识别的用户。”
	 * @param rid	角色编号
	 * @param uids	用户编号集合
	 * @throws BusinessException	业务异常
	 */
	@RequestMapping(value="/createRoleUserRef.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData createRoleUserRef(String rid, String[] uids){
		try{
			RoleUserRefEntity roleUserRefEntity=new RoleUserRefEntity ();//穿此实体类目的是为了接收切面的创建者创建时间
			roleService.createRoleUserRef(roleUserRefEntity,rid, uids);
			return new ResponseData(true,RoleConstants.CREATE_ROLEUSERREF_SUCCESS);
		}catch(BusinessException e){
			return new ResponseData(false,e.getErrorCode(),e.getMessage(),null);
		}
	}
	
	/**
	 * 根据编号删除角色
	 * @param id	角色编号
	 */
	@RequestMapping(value="/deleteRoleById.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData deleteRoleById(String id){
		if(id==null){
			return new ResponseData(false,RoleConstants.ERROE_CODE_NULL,RoleConstants.ROLE_ID_ISNULL,null);
		}
		roleService.deleteRoleById(id);
		return new ResponseData(true,RoleConstants.DELETE_ROLE_SUCCESS);	
	}	
	
	/**
	 * 根据角色编号、用户编号集合删除角色用户关系
	 * @param rid	角色编号
	 * @param uids	用户编号集合
	 */
	@RequestMapping(value="/deleteRoleUserRef.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData deleteRoleUserRef(String rid, String[] uids){
		if(rid==null){
			return new ResponseData(false,RoleConstants.ERROE_CODE_NULL,RoleConstants.ROLE_ID_ISNULL,null);
		}
		if(uids==null){
			return new ResponseData(false,UserConstants.ERROE_CODE_NULL,UserConstants.USER_ID_ISNULL,null);
		}
		roleService.deleteRoleUserRef(rid, uids);
		return new ResponseData(true,RoleConstants.DELETE_ROLEUSERREF_SUCCESS);		
	}
	
	/**
	 * 更新角色
	 * 更新指定角色信息，包含名称、描述、更新者、更新时间
	 * @param roleData	角色传输实体
	 * @throws BusinessException	业务异常
	 */
	@RequestMapping(value="/updateRole.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData updateRole(RoleData roleData){
		try{
			roleService.updateRole(roleData.toRoleEntity());
			return new ResponseData(true,RoleConstants.UPDATE_ROLE_SUCCESS);
		}catch(BusinessException e){
			return new ResponseData(false,e.getErrorCode(),e.getMessage(),null);
		}
	}
	
	/**
	 * 创建和更新角色资源关系
	 * 先清空角色编号为roleId的关系、再创建角色编号为roleId、资源编号为resourceId的关系
	 * 若roleId对应的角色不存在，则抛出业务异常“更新失败，角色不存在。”；若有一个resourceId对应的资源不存在，则抛出业务异常“更新失败，存在无法识别的资源。”
	 * 0个资源表示解绑角色资源关系，即删除
	 * @param roleId	角色编号
	 * @param resourceIds	资源编号集合
	 * @throws BusinessException	业务异常
	 */
	@RequestMapping(value="/updateRoleResourceRef.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData updateRoleResourceRef(String roleId, String[] resourceIds){
		try{
			ResourcePermissionEntity resourcePermissionEntity=new ResourcePermissionEntity ();//穿此实体类目的是为了接收切面的创建者创建时间
			roleService.updateRoleResourceRef(resourcePermissionEntity,roleId, resourceIds);
			return new ResponseData(true,RoleConstants.UPDATE_EOLEUSERREF_DUCCESS);
		}catch(BusinessException e){
			return new ResponseData(false,e.getErrorCode(),e.getMessage(),null);
		}
	}
	
	/**
	 * 根据编号检索角色
	 * @param id	角色编号
	 * @return	角色实体
	 */
	@RequestMapping(value="/retrieveRoleById.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData retrieveRoleById(String id){
		if(id==null){
			return new ResponseData(false,RoleConstants.ERROE_CODE_NULL,RoleConstants.ROLE_ID_ISNULL,null);
		}
		RoleEntity roleEntity=roleService.retrieveRoleById(id);
		return new ResponseData(true,getRoleData(roleEntity));		
	}
	
	/**
	 * 根据应用编号检索角色
	 * @param aid	应用编号
	 * @return	角色集合
	 */
	@RequestMapping(value="/retrieveRolesByAid.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData retrieveRolesByAid(String aid){
		//此处不需要判断应用编号是否为空，如果为空，则查询全部角色
			RoleEntity roleEntity=new RoleEntity();
			roleEntity.setAid(aid);
			List<RoleEntity> roleEntitys=roleService.retrieveRolesByAid(roleEntity.getAid());
			return new ResponseData(true,getRoleDatas(roleEntitys));	
	}

	/**
	 * 根据角色编号获取资源
	 * @param rid	角色编号
	 * @return	资源集合
	 */
	/*@RequestMapping(value="/retrieveResourcesByRoleId.service" ,method=RequestMethod.POST)
	@ResponseBody
	public ResponseData retrieveResourcesByRoleId(String rid){
		if(rid==null){
			return new ResponseData(false,RoleConstants.ERROE_CODE_NULL,RoleConstants.ROLE_ID_ISNULL,null);
		}
		List<ResourceEntity> resourceEntitys=resourceService.retrieveResourcesByRoleId(rid);
		return new ResponseData(true,getResourceDatas(resourceEntitys));		
	}*/
	
	
	/**
	 * 为用户分配角色  以Map的形式的数据传给前台
	 */
	@RequestMapping(value="/retrieveUserRoles.service")
	@ResponseBody
	public ResponseMapData retrieveUserRoles(){
		ApplicationEntity appEntity = new ApplicationEntity();
		List<ApplicationEntity> applications=applicationService.retrieveApplications(appEntity);
		List<String> apps = new ArrayList<String>();
		Map<String,List<RoleEntity>> map=new HashMap<String,List<RoleEntity>>();
		List<RoleEntity> AllRoles=roleService.retrieveRolesByAid("");
		for (ApplicationEntity app : applications) {
			String aname = app.getName();
			List<RoleEntity> roles=new ArrayList<RoleEntity>();
			for (RoleEntity role : AllRoles) {
				if(role.getAname().equals(aname)) {
					roles.add(role);
				}
			}
			apps.add(aname);
			map.put(aname, roles);
		}
		return new ResponseMapData(true, map, apps);
	}
	
	/**
	 * 根据用户编号获取用户角色对应关系
	 * @param uid	用户编号
	 * @return	用户角色对应关系
	 */
	@RequestMapping(value="/retrieveRolesUserRefByUid.service" ,method=RequestMethod.POST)
	@ResponseBody
	public ResponseData retrieveRolesUserRefByUid(String uid){
		if(uid==null){
			return new ResponseData(false,UserConstants.ERROE_CODE_NULL,UserConstants.USER_ID_ISNULL,null);
		}
		List<RoleUserRefEntity> roles=roleService.retrieveRolesUserRefByUid(uid);
		return new ResponseData(true,roles);
	}

	/**
	 * 前台验证角色 的名称 （添加和更新） 
	 * @param roleEntity
	 * @return 
	 */
	@RequestMapping(value="/validationRole.service",method=RequestMethod.POST)
	@ResponseBody
	public ResponseData validationRole(RoleData roleData){
		if(StringUtil.isBlank(roleData.getName())){
			return new ResponseData(false,ErrorConstants.DATA_NULL_CODE,ErrorConstants.DATA_NULL_MESSAGE,null);
		}		
		try{
			roleService.validationRole(roleData.toRoleEntity());
			return new ResponseData(true,ErrorConstants.SUCCESS_CODE,ErrorConstants.SUCCESS_MESSAGE,null);
		}catch(BusinessException e){
			return new ResponseData(false,e.getErrorCode(),e.getMessage(),null);
		}
		/*String validationCode=roleService.validationRole(roleData.toRoleEntity());
		if(validationCode.equals(ErrorConstants.REPEAT_NO_SAVE_CODE)){
			return new ResponseData(false,validationCode,ErrorConstants.REPEAT_NO_SAVE_MESSAGE,null);
		}
		return new ResponseData(true,validationCode,ErrorConstants.SUCCESS_MESSAGE,null);*/		
	}
	
	/**
	 * 资源实体类转化传输类
	 * @param entity
	 * @return data
	 */
	private RoleData getRoleData(RoleEntity entity){
		RoleData data = new RoleData();
		data.toRoleData(entity);
		return data;
	}

	/**
	 * 获取角色传输数据
	 * 将实体类转换成传输数据集合
	 * @param roles	角色实体数据集合
	 * @return	角色传输数据集合
	 */
	private List<RoleData> getRoleDatas(List<RoleEntity> roles){
		int size = roles.size();
		List<RoleData> roleDatas = new ArrayList<RoleData>(); 
		for(int i=0;i<size;i++){
			RoleData roledata = new RoleData();
			roledata.toRoleData(roles.get(i));
			roleDatas.add(roledata);
		}
		return roleDatas;
	}
	
	/**
	 * 获取资源传输数据
	 * 将实体数据集合转换为传输数据集合
	 * @param resources	资源实体数据集合
	 * @return	资源传输数据集合
	 *//*
	private List<ResourceData> getResourceDatas(List<ResourceEntity> resources) {
		int size = resources.size();
		List<ResourceData> resourceDatas = new ArrayList<ResourceData> ();
		for(int i=0; i<size; i++) {	//	循环将实体数据转换为传输数据
			ResourceData resourceData = new ResourceData();
			resourceData.toResourceData(resources.get(i));
			resourceDatas.add(resourceData);
		}
		return resourceDatas;
	}*/
}
